home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / mapix.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  28.0 KB  |  561 lines
  1. /*
  2.  *  M A P I X . H
  3.  *
  4.  *  Definitions of objects/flags, etc used by Extended MAPI.
  5.  *
  6.  *  Copyright 1986-1996 Microsoft Corporation. All Rights Reserved.
  7.  */
  8.  
  9. #ifndef MAPIX_H
  10. #define MAPIX_H
  11. #pragma option push -b
  12.  
  13.  
  14. /* Include common MAPI header files if they haven't been already. */
  15. #ifndef MAPIDEFS_H
  16.  
  17. #include <mapidefs.h>
  18.  
  19. #endif
  20. #ifndef MAPICODE_H
  21.  
  22. #include <mapicode.h>
  23.  
  24. #endif
  25. #ifndef MAPIGUID_H
  26.  
  27. #include <mapiguid.h>
  28.  
  29. #endif
  30. #ifndef MAPITAGS_H
  31.  
  32. #include <mapitags.h>
  33.  
  34. #endif
  35.  
  36. #ifdef __BORLANDC__
  37. #  include <pshpack8.h>
  38. #endif
  39.  
  40. #ifdef  __cplusplus
  41. extern "C" {
  42. #endif
  43.  
  44. #ifndef BEGIN_INTERFACE
  45. #define BEGIN_INTERFACE
  46. #endif
  47.  
  48. /* Forward interface declarations */
  49.  
  50. DECLARE_MAPI_INTERFACE_PTR(IProfAdmin,          LPPROFADMIN);
  51. DECLARE_MAPI_INTERFACE_PTR(IMsgServiceAdmin,    LPSERVICEADMIN);
  52. DECLARE_MAPI_INTERFACE_PTR(IMAPISession,        LPMAPISESSION);
  53.  
  54. /* ------------------------------------------------------ */
  55. /* shared with simple mapi */
  56.  
  57. typedef ULONG       FLAGS;
  58.  
  59. /* MAPILogon() flags.       */
  60.  
  61. #define MAPI_LOGON_UI           0x00000001  /* Display logon UI                 */
  62. #define MAPI_NEW_SESSION        0x00000002  /* Don't use shared session         */
  63. #define MAPI_ALLOW_OTHERS       0x00000008  /* Make this a shared session       */
  64. #define MAPI_EXPLICIT_PROFILE   0x00000010  /* Don't use default profile        */
  65. #define MAPI_EXTENDED           0x00000020  /* Extended MAPI Logon              */
  66. #define MAPI_FORCE_DOWNLOAD     0x00001000  /* Get new mail before return       */
  67. #define MAPI_SERVICE_UI_ALWAYS  0x00002000  /* Do logon UI in all providers     */
  68. #define MAPI_NO_MAIL            0x00008000  /* Do not activate transports       */
  69. #define MAPI_NT_SERVICE         0x00010000  /* Allow logon from an NT service   */
  70. #ifndef MAPI_PASSWORD_UI
  71. #define MAPI_PASSWORD_UI        0x00020000  /* Display password UI only         */
  72. #endif
  73. #define MAPI_TIMEOUT_SHORT      0x00100000  /* Minimal wait for logon resources */
  74.  
  75. #define MAPI_SIMPLE_DEFAULT (MAPI_LOGON_UI | MAPI_FORCE_DOWNLOAD | MAPI_ALLOW_OTHERS)
  76. #define MAPI_SIMPLE_EXPLICIT (MAPI_NEW_SESSION | MAPI_FORCE_DOWNLOAD | MAPI_EXPLICIT_PROFILE)
  77.  
  78. /* Structure passed to MAPIInitialize(), and its ulFlags values */
  79.  
  80. typedef struct
  81. {
  82.     ULONG           ulVersion;
  83.     ULONG           ulFlags;
  84. } MAPIINIT_0, FAR *LPMAPIINIT_0;
  85.  
  86. typedef MAPIINIT_0 MAPIINIT;
  87. typedef MAPIINIT FAR *LPMAPIINIT;
  88.  
  89. #define MAPI_INIT_VERSION               0
  90.  
  91. #define MAPI_MULTITHREAD_NOTIFICATIONS  0x00000001
  92. /* Reserved for MAPI                    0x40000000 */
  93. /* #define MAPI_NT_SERVICE              0x00010000  Use from NT service */
  94.  
  95. /* MAPI base functions */
  96.  
  97. typedef HRESULT (STDAPICALLTYPE MAPIINITIALIZE)(
  98.     LPVOID          lpMapiInit
  99. );
  100. typedef MAPIINITIALIZE FAR *LPMAPIINITIALIZE;
  101.  
  102. typedef void (STDAPICALLTYPE MAPIUNINITIALIZE)(void);
  103. typedef MAPIUNINITIALIZE FAR *LPMAPIUNINITIALIZE;
  104.  
  105. MAPIINITIALIZE      MAPIInitialize;
  106. MAPIUNINITIALIZE    MAPIUninitialize;
  107.  
  108.  
  109. /*  Extended MAPI Logon function */
  110.  
  111.  
  112. typedef HRESULT (STDMETHODCALLTYPE MAPILOGONEX)(
  113.     ULONG ulUIParam,
  114.     LPTSTR lpszProfileName,
  115.     LPTSTR lpszPassword,
  116.     ULONG ulFlags,   /*  ulFlags takes all that SimpleMAPI does + MAPI_UNICODE */
  117.     LPMAPISESSION FAR * lppSession
  118. );
  119. typedef MAPILOGONEX FAR *LPMAPILOGONEX;
  120.  
  121. MAPILOGONEX MAPILogonEx;
  122.  
  123.  
  124. typedef SCODE (STDMETHODCALLTYPE MAPIALLOCATEBUFFER)(
  125.     ULONG           cbSize,
  126.     LPVOID FAR *    lppBuffer
  127. );
  128.  
  129. typedef SCODE (STDMETHODCALLTYPE MAPIALLOCATEMORE)(
  130.     ULONG           cbSize,
  131.     LPVOID          lpObject,
  132.     LPVOID FAR *    lppBuffer
  133. );
  134.  
  135. typedef ULONG (STDAPICALLTYPE MAPIFREEBUFFER)(
  136.     LPVOID          lpBuffer
  137. );
  138.  
  139. typedef MAPIALLOCATEBUFFER FAR  *LPMAPIALLOCATEBUFFER;
  140. typedef MAPIALLOCATEMORE FAR    *LPMAPIALLOCATEMORE;
  141. typedef MAPIFREEBUFFER FAR      *LPMAPIFREEBUFFER;
  142.  
  143. MAPIALLOCATEBUFFER MAPIAllocateBuffer;
  144. MAPIALLOCATEMORE MAPIAllocateMore;
  145. MAPIFREEBUFFER MAPIFreeBuffer;
  146.  
  147. typedef HRESULT (STDMETHODCALLTYPE MAPIADMINPROFILES)(
  148.     ULONG ulFlags,
  149.     LPPROFADMIN FAR *lppProfAdmin
  150. );
  151.  
  152. typedef MAPIADMINPROFILES FAR *LPMAPIADMINPROFILES;
  153.  
  154. MAPIADMINPROFILES MAPIAdminProfiles;
  155.  
  156. /* IMAPISession Interface -------------------------------------------------- */
  157.  
  158. /* Flags for OpenEntry and others */
  159.  
  160. /*#define MAPI_MODIFY               ((ULONG) 0x00000001) */
  161.  
  162. /* Flags for Logoff */
  163.  
  164. #define MAPI_LOGOFF_SHARED      0x00000001  /* Close all shared sessions    */
  165. #define MAPI_LOGOFF_UI          0x00000002  /* It's OK to present UI        */
  166.  
  167. /* Flags for SetDefaultStore. They are mutually exclusive. */
  168.  
  169. #define MAPI_DEFAULT_STORE          0x00000001  /* for incoming messages */
  170. #define MAPI_SIMPLE_STORE_TEMPORARY 0x00000002  /* for simple MAPI and CMC */
  171. #define MAPI_SIMPLE_STORE_PERMANENT 0x00000003  /* for simple MAPI and CMC */
  172. #define MAPI_PRIMARY_STORE          0x00000004  /* Used by some clients */
  173. #define MAPI_SECONDARY_STORE        0x00000005  /* Used by some clients */
  174.  
  175. /* Flags for ShowForm. */
  176.  
  177. #define MAPI_POST_MESSAGE       0x00000001  /* Selects post/send semantics */
  178. #define MAPI_NEW_MESSAGE        0x00000002  /* Governs copying during submission */
  179.  
  180. /*  MessageOptions */
  181. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  182.  
  183. /*  QueryDefaultMessageOpt */
  184. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  185.  
  186. #define MAPI_IMAPISESSION_METHODS(IPURE)                                \
  187.     MAPIMETHOD(GetLastError)                                            \
  188.         (THIS_  HRESULT                     hResult,                    \
  189.                 ULONG                       ulFlags,                    \
  190.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  191.     MAPIMETHOD(GetMsgStoresTable)                                       \
  192.         (THIS_  ULONG                       ulFlags,                    \
  193.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  194.     MAPIMETHOD(OpenMsgStore)                                            \
  195.         (THIS_  ULONG                       ulUIParam,                  \
  196.                 ULONG                       cbEntryID,                  \
  197.                 LPENTRYID                   lpEntryID,                  \
  198.                 LPCIID                      lpInterface,                \
  199.                 ULONG                       ulFlags,                    \
  200.                 LPMDB FAR *                 lppMDB) IPURE;              \
  201.     MAPIMETHOD(OpenAddressBook)                                         \
  202.         (THIS_  ULONG                       ulUIParam,                  \
  203.                 LPCIID                      lpInterface,                \
  204.                 ULONG                       ulFlags,                    \
  205.                 LPADRBOOK FAR *             lppAdrBook) IPURE;          \
  206.     MAPIMETHOD(OpenProfileSection)                                      \
  207.         (THIS_  LPMAPIUID                   lpUID,                      \
  208.                 LPCIID                      lpInterface,                \
  209.                 ULONG                       ulFlags,                    \
  210.                 LPPROFSECT FAR *            lppProfSect) IPURE;         \
  211.     MAPIMETHOD(GetStatusTable)                                          \
  212.         (THIS_  ULONG                       ulFlags,                    \
  213.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  214.     MAPIMETHOD(OpenEntry)                                               \
  215.         (THIS_  ULONG                       cbEntryID,                  \
  216.                 LPENTRYID                   lpEntryID,                  \
  217.                 LPCIID                      lpInterface,                \
  218.                 ULONG                       ulFlags,                    \
  219.                 ULONG FAR *                 lpulObjType,                \
  220.                 LPUNKNOWN FAR *             lppUnk) IPURE;  \
  221.     MAPIMETHOD(CompareEntryIDs)                                         \
  222.         (THIS_  ULONG                       cbEntryID1,                 \
  223.                 LPENTRYID                   lpEntryID1,                 \
  224.                 ULONG                       cbEntryID2,                 \
  225.                 LPENTRYID                   lpEntryID2,                 \
  226.                 ULONG                       ulFlags,                    \
  227.                 ULONG FAR *                 lpulResult) IPURE;          \
  228.     MAPIMETHOD(Advise)                                                  \
  229.         (THIS_  ULONG                       cbEntryID,                  \
  230.                 LPENTRYID                   lpEntryID,                  \
  231.                 ULONG                       ulEventMask,                \
  232.                 LPMAPIADVISESINK            lpAdviseSink,               \
  233.                 ULONG FAR *                 lpulConnection) IPURE;      \
  234.     MAPIMETHOD(Unadvise)                                                \
  235.         (THIS_  ULONG                       ulConnection) IPURE;        \
  236.     MAPIMETHOD(MessageOptions)                                          \
  237.         (THIS_  ULONG                       ulUIParam,                  \
  238.                 ULONG                       ulFlags,                    \
  239.                 LPTSTR                      lpszAdrType,                \
  240.                 LPMESSAGE                   lpMessage) IPURE;           \
  241.     MAPIMETHOD(QueryDefaultMessageOpt)                                  \
  242.         (THIS_  LPTSTR                      lpszAdrType,                \
  243.                 ULONG                       ulFlags,                    \
  244.                 ULONG FAR *                 lpcValues,                  \
  245.                 LPSPropValue FAR *          lppOptions) IPURE;          \
  246.     MAPIMETHOD(EnumAdrTypes)                                            \
  247.         (THIS_  ULONG                       ulFlags,                    \
  248.                 ULONG FAR *                 lpcAdrTypes,                \
  249.                 LPTSTR FAR * FAR *          lpppszAdrTypes) IPURE;      \
  250.     MAPIMETHOD(QueryIdentity)                                           \
  251.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  252.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  253.     MAPIMETHOD(Logoff)                                                  \
  254.         (THIS_  ULONG                       ulUIParam,                  \
  255.                 ULONG                       ulFlags,                    \
  256.                 ULONG                       ulReserved) IPURE;          \
  257.     MAPIMETHOD(SetDefaultStore)                                         \
  258.         (THIS_  ULONG                       ulFlags,                    \
  259.                 ULONG                       cbEntryID,                  \
  260.                 LPENTRYID                   lpEntryID) IPURE;           \
  261.     MAPIMETHOD(AdminServices)                                           \
  262.         (THIS_  ULONG                       ulFlags,                    \
  263.                 LPSERVICEADMIN FAR *        lppServiceAdmin) IPURE;     \
  264.     MAPIMETHOD(ShowForm)                                                \
  265.         (THIS_  ULONG                       ulUIParam,                  \
  266.                 LPMDB                       lpMsgStore,                 \
  267.                 LPMAPIFOLDER                lpParentFolder,             \
  268.                 LPCIID                      lpInterface,                \
  269.                 ULONG                       ulMessageToken,             \
  270.                 LPMESSAGE                   lpMessageSent,              \
  271.                 ULONG                       ulFlags,                    \
  272.                 ULONG                       ulMessageStatus,            \
  273.                 ULONG                       ulMessageFlags,             \
  274.                 ULONG                       ulAccess,                   \
  275.                 LPSTR                       lpszMessageClass) IPURE;    \
  276.     MAPIMETHOD(PrepareForm)                                             \
  277.         (THIS_  LPCIID                      lpInterface,                \
  278.                 LPMESSAGE                   lpMessage,                  \
  279.                 ULONG FAR *                 lpulMessageToken) IPURE;    \
  280.  
  281.  
  282. #undef       INTERFACE
  283. #define      INTERFACE  IMAPISession
  284. DECLARE_MAPI_INTERFACE_(IMAPISession, IUnknown)
  285. {
  286.     BEGIN_INTERFACE 
  287.     MAPI_IUNKNOWN_METHODS(PURE)
  288.     MAPI_IMAPISESSION_METHODS(PURE)
  289. };
  290.  
  291. /*DECLARE_MAPI_INTERFACE_PTR(IMAPISession, LPMAPISESSION);*/
  292.  
  293. /* IAddrBook Interface ----------------------------------------------------- */
  294.  
  295. /*  CreateOneOff */
  296. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  297. /****** MAPI_SEND_NO_RICH_INFO      ((ULONG) 0x00010000) */
  298.  
  299. /*  RecipOptions */
  300. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  301.  
  302. /*  QueryDefaultRecipOpt */
  303. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  304.  
  305. /*  GetSearchPath */
  306. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  307.  
  308.  
  309. #define MAPI_IADDRBOOK_METHODS(IPURE)                                   \
  310.     MAPIMETHOD(OpenEntry)                                               \
  311.         (THIS_  ULONG                       cbEntryID,                  \
  312.                 LPENTRYID                   lpEntryID,                  \
  313.                 LPCIID                      lpInterface,                \
  314.                 ULONG                       ulFlags,                    \
  315.                 ULONG FAR *                 lpulObjType,                \
  316.                 LPUNKNOWN FAR *             lppUnk) IPURE;  \
  317.     MAPIMETHOD(CompareEntryIDs)                                         \
  318.         (THIS_  ULONG                       cbEntryID1,                 \
  319.                 LPENTRYID                   lpEntryID1,                 \
  320.                 ULONG                       cbEntryID2,                 \
  321.                 LPENTRYID                   lpEntryID2,                 \
  322.                 ULONG                       ulFlags,                    \
  323.                 ULONG FAR *                 lpulResult) IPURE;          \
  324.     MAPIMETHOD(Advise)                                                  \
  325.         (THIS_  ULONG                       cbEntryID,                  \
  326.                 LPENTRYID                   lpEntryID,                  \
  327.                 ULONG                       ulEventMask,                \
  328.                 LPMAPIADVISESINK            lpAdviseSink,               \
  329.                 ULONG FAR *                 lpulConnection) IPURE;      \
  330.     MAPIMETHOD(Unadvise)                                                \
  331.         (THIS_  ULONG                       ulConnection) IPURE;        \
  332.     MAPIMETHOD(CreateOneOff)                                            \
  333.         (THIS_  LPTSTR                      lpszName,                   \
  334.                 LPTSTR                      lpszAdrType,                \
  335.                 LPTSTR                      lpszAddress,                \
  336.                 ULONG                       ulFlags,                    \
  337.                 ULONG FAR *                 lpcbEntryID,                \
  338.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  339.     MAPIMETHOD(NewEntry)                                                \
  340.         (THIS_  ULONG                       ulUIParam,                  \
  341.                 ULONG                       ulFlags,                    \
  342.                 ULONG                       cbEIDContainer,             \
  343.                 LPENTRYID                   lpEIDContainer,             \
  344.                 ULONG                       cbEIDNewEntryTpl,           \
  345.                 LPENTRYID                   lpEIDNewEntryTpl,           \
  346.                 ULONG FAR *                 lpcbEIDNewEntry,            \
  347.                 LPENTRYID FAR *             lppEIDNewEntry) IPURE;      \
  348.     MAPIMETHOD(ResolveName)                                             \
  349.         (THIS_  ULONG                       ulUIParam,                  \
  350.                 ULONG                       ulFlags,                    \
  351.                 LPTSTR                      lpszNewEntryTitle,          \
  352.                 LPADRLIST                   lpAdrList) IPURE;           \
  353.     MAPIMETHOD(Address)                                                 \
  354.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  355.                 LPADRPARM                   lpAdrParms,                 \
  356.                 LPADRLIST FAR *             lppAdrList) IPURE;          \
  357.     MAPIMETHOD(Details)                                                 \
  358.         (THIS_  ULONG FAR *                 lpulUIParam,                \
  359.                 LPFNDISMISS                 lpfnDismiss,                \
  360.                 LPVOID                      lpvDismissContext,          \
  361.                 ULONG                       cbEntryID,                  \
  362.                 LPENTRYID                   lpEntryID,                  \
  363.                 LPFNBUTTON                  lpfButtonCallback,          \
  364.                 LPVOID                      lpvButtonContext,           \
  365.                 LPTSTR                      lpszButtonText,             \
  366.                 ULONG                       ulFlags) IPURE;             \
  367.     MAPIMETHOD(RecipOptions)                                            \
  368.         (THIS_  ULONG                       ulUIParam,                  \
  369.                 ULONG                       ulFlags,                    \
  370.                 LPADRENTRY                  lpRecip) IPURE;             \
  371.     MAPIMETHOD(QueryDefaultRecipOpt)                                    \
  372.         (THIS_  LPTSTR                      lpszAdrType,                \
  373.                 ULONG                       ulFlags,                    \
  374.                 ULONG FAR *                 lpcValues,                  \
  375.                 LPSPropValue FAR *          lppOptions) IPURE;          \
  376.     MAPIMETHOD(GetPAB)                                                  \
  377.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  378.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  379.     MAPIMETHOD(SetPAB)                                                  \
  380.         (THIS_  ULONG                       cbEntryID,                  \
  381.                 LPENTRYID                   lpEntryID) IPURE;           \
  382.     MAPIMETHOD(GetDefaultDir)                                           \
  383.         (THIS_  ULONG FAR *                 lpcbEntryID,                \
  384.                 LPENTRYID FAR *             lppEntryID) IPURE;          \
  385.     MAPIMETHOD(SetDefaultDir)                                           \
  386.         (THIS_  ULONG                       cbEntryID,                  \
  387.                 LPENTRYID                   lpEntryID) IPURE;           \
  388.     MAPIMETHOD(GetSearchPath)                                           \
  389.         (THIS_  ULONG                       ulFlags,                    \
  390.                 LPSRowSet FAR *             lppSearchPath) IPURE;       \
  391.     MAPIMETHOD(SetSearchPath)                                           \
  392.         (THIS_  ULONG                       ulFlags,                    \
  393.                 LPSRowSet                   lpSearchPath) IPURE;        \
  394.     MAPIMETHOD(PrepareRecips)                                           \
  395.         (THIS_  ULONG                       ulFlags,                    \
  396.                 LPSPropTagArray             lpPropTagArray,             \
  397.                 LPADRLIST                   lpRecipList) IPURE;         \
  398.  
  399. #undef       INTERFACE
  400. #define      INTERFACE  IAddrBook
  401. DECLARE_MAPI_INTERFACE_(IAddrBook, IMAPIProp)
  402. {
  403.     BEGIN_INTERFACE 
  404.     MAPI_IUNKNOWN_METHODS(PURE)
  405.     MAPI_IMAPIPROP_METHODS(PURE)
  406.     MAPI_IADDRBOOK_METHODS(PURE)
  407. };
  408.  
  409. DECLARE_MAPI_INTERFACE_PTR(IAddrBook, LPADRBOOK);
  410.  
  411. /* IProfAdmin Interface ---------------------------------------------------- */
  412.  
  413. /* Flags for CreateProfile */
  414. #define MAPI_DEFAULT_SERVICES           0x00000001
  415.  
  416. /* GetProfileTable */
  417. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  418.  
  419. #define MAPI_IPROFADMIN_METHODS(IPURE)                                  \
  420.     MAPIMETHOD(GetLastError)                                            \
  421.         (THIS_  HRESULT                     hResult,                    \
  422.                 ULONG                       ulFlags,                    \
  423.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  424.     MAPIMETHOD(GetProfileTable)                                         \
  425.         (THIS_  ULONG                       ulFlags,                    \
  426.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  427.     MAPIMETHOD(CreateProfile)                                           \
  428.         (THIS_  LPTSTR                      lpszProfileName,            \
  429.                 LPTSTR                      lpszPassword,               \
  430.                 ULONG                       ulUIParam,                  \
  431.                 ULONG                       ulFlags) IPURE;             \
  432.     MAPIMETHOD(DeleteProfile)                                           \
  433.         (THIS_  LPTSTR                      lpszProfileName,            \
  434.                 ULONG                       ulFlags) IPURE;             \
  435.     MAPIMETHOD(ChangeProfilePassword)                                   \
  436.         (THIS_  LPTSTR                      lpszProfileName,            \
  437.                 LPTSTR                      lpszOldPassword,            \
  438.                 LPTSTR                      lpszNewPassword,            \
  439.                 ULONG                       ulFlags) IPURE;             \
  440.     MAPIMETHOD(CopyProfile)                                             \
  441.         (THIS_  LPTSTR                      lpszOldProfileName,         \
  442.                 LPTSTR                      lpszOldPassword,            \
  443.                 LPTSTR                      lpszNewProfileName,         \
  444.                 ULONG                       ulUIParam,                  \
  445.                 ULONG                       ulFlags) IPURE;             \
  446.     MAPIMETHOD(RenameProfile)                                           \
  447.         (THIS_  LPTSTR                      lpszOldProfileName,         \
  448.                 LPTSTR                      lpszOldPassword,            \
  449.                 LPTSTR                      lpszNewProfileName,         \
  450.                 ULONG                       ulUIParam,                  \
  451.                 ULONG                       ulFlags) IPURE;             \
  452.     MAPIMETHOD(SetDefaultProfile)                                       \
  453.         (THIS_  LPTSTR                      lpszProfileName,            \
  454.                 ULONG                       ulFlags) IPURE;             \
  455.     MAPIMETHOD(AdminServices)                                           \
  456.         (THIS_  LPTSTR                      lpszProfileName,            \
  457.                 LPTSTR                      lpszPassword,               \
  458.                 ULONG                       ulUIParam,                  \
  459.                 ULONG                       ulFlags,                    \
  460.                 LPSERVICEADMIN FAR *        lppServiceAdmin) IPURE;     \
  461.  
  462.  
  463. #undef       INTERFACE
  464. #define      INTERFACE  IProfAdmin
  465. DECLARE_MAPI_INTERFACE_(IProfAdmin, IUnknown)
  466. {
  467.     BEGIN_INTERFACE 
  468.     MAPI_IUNKNOWN_METHODS(PURE)
  469.     MAPI_IPROFADMIN_METHODS(PURE)
  470. };
  471.  
  472. /* IMsgServiceAdmin Interface ---------------------------------------------- */
  473.  
  474. /* Values for PR_RESOURCE_FLAGS in message service table */
  475.  
  476. #define SERVICE_DEFAULT_STORE       0x00000001
  477. #define SERVICE_SINGLE_COPY         0x00000002
  478. #define SERVICE_CREATE_WITH_STORE   0x00000004
  479. #define SERVICE_PRIMARY_IDENTITY    0x00000008
  480. #define SERVICE_NO_PRIMARY_IDENTITY 0x00000020
  481.  
  482. /*  GetMsgServiceTable */
  483. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  484.  
  485. /*  GetProviderTable */
  486. /****** MAPI_UNICODE            ((ULONG) 0x80000000) */
  487.  
  488. #define MAPI_IMSGSERVICEADMIN_METHODS(IPURE)                            \
  489.     MAPIMETHOD(GetLastError)                                            \
  490.         (THIS_  HRESULT                     hResult,                    \
  491.                 ULONG                       ulFlags,                    \
  492.                 LPMAPIERROR FAR *           lppMAPIError) IPURE;        \
  493.     MAPIMETHOD(GetMsgServiceTable)                                      \
  494.         (THIS_  ULONG                       ulFlags,                    \
  495.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  496.     MAPIMETHOD(CreateMsgService)                                        \
  497.         (THIS_  LPTSTR                      lpszService,                \
  498.                 LPTSTR                      lpszDisplayName,            \
  499.                 ULONG                       ulUIParam,                  \
  500.                 ULONG                       ulFlags) IPURE;             \
  501.     MAPIMETHOD(DeleteMsgService)                                        \
  502.         (THIS_  LPMAPIUID                   lpUID) IPURE;               \
  503.     MAPIMETHOD(CopyMsgService)                                          \
  504.         (THIS_  LPMAPIUID                   lpUID,                      \
  505.                 LPTSTR                      lpszDisplayName,            \
  506.                 LPCIID                      lpInterfaceToCopy,          \
  507.                 LPCIID                      lpInterfaceDst,             \
  508.                 LPVOID                      lpObjectDst,                \
  509.                 ULONG                       ulUIParam,                  \
  510.                 ULONG                       ulFlags) IPURE;             \
  511.     MAPIMETHOD(RenameMsgService)                                        \
  512.         (THIS_  LPMAPIUID                   lpUID,                      \
  513.                 ULONG                       ulFlags,                    \
  514.                 LPTSTR                      lpszDisplayName) IPURE;     \
  515.     MAPIMETHOD(ConfigureMsgService)                                     \
  516.         (THIS_  LPMAPIUID                   lpUID,                      \
  517.                 ULONG                       ulUIParam,                  \
  518.                 ULONG                       ulFlags,                    \
  519.                 ULONG                       cValues,                    \
  520.                 LPSPropValue                lpProps) IPURE;             \
  521.     MAPIMETHOD(OpenProfileSection)                                      \
  522.         (THIS_  LPMAPIUID                   lpUID,                      \
  523.                 LPCIID                      lpInterface,                \
  524.                 ULONG                       ulFlags,                    \
  525.                 LPPROFSECT FAR *            lppProfSect) IPURE;         \
  526.     MAPIMETHOD(MsgServiceTransportOrder)                                \
  527.         (THIS_  ULONG                       cUID,                       \
  528.                 LPMAPIUID                   lpUIDList,                  \
  529.                 ULONG                       ulFlags) IPURE;             \
  530.     MAPIMETHOD(AdminProviders)                                          \
  531.         (THIS_  LPMAPIUID                   lpUID,                      \
  532.                 ULONG                       ulFlags,                    \
  533.                 LPPROVIDERADMIN FAR *       lppProviderAdmin) IPURE;    \
  534.     MAPIMETHOD(SetPrimaryIdentity)                                      \
  535.         (THIS_  LPMAPIUID                   lpUID,                      \
  536.                 ULONG                       ulFlags) IPURE;             \
  537.     MAPIMETHOD(GetProviderTable)                                        \
  538.         (THIS_  ULONG                       ulFlags,                    \
  539.                 LPMAPITABLE FAR *           lppTable) IPURE;            \
  540.  
  541.  
  542. #undef       INTERFACE
  543. #define      INTERFACE  IMsgServiceAdmin
  544. DECLARE_MAPI_INTERFACE_(IMsgServiceAdmin, IUnknown)
  545. {
  546.     BEGIN_INTERFACE 
  547.     MAPI_IUNKNOWN_METHODS(PURE)
  548.     MAPI_IMSGSERVICEADMIN_METHODS(PURE)
  549. };
  550.  
  551. #ifdef  __cplusplus
  552. }       /*  extern "C" */
  553. #endif  
  554.  
  555. #ifdef __BORLANDC__
  556. #  include <poppack.h>
  557. #endif
  558.  
  559. #pragma option pop
  560. #endif /* MAPIX_H */
  561.